package org.example;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/**
 * Callable创建线程
 * 1. 有返回值
 * 2. 可以抛出异常
 * 3. 实现方法不同（call）
 */
public class CallableTest {
    public static void main(String[] args) {
        // 需要通过 Thread 创建线程

        // Runnable方式
        new Thread(new RunnableImp()).start();

        // 而 Thread 只有 public Thread(Runnable target)
        /* 通过查看JDK发现
                public class FutureTask<V> implements RunnableFuture<V>
           ==>  public interface RunnableFuture<V> extends Runnable, Future<V>
           ==>  public FutureTask(Callable<V> callable)
         */
        FutureTask<Integer> task = new FutureTask<>(new CallableImp());
        new Thread(task,"1").start();
        new Thread(task,"2").start();   // 多个线程执行一个task，只会执行一次call方法
        try {
            Integer i = task.get();   // 可能阻塞，所有一般放到最后一行 或 异步通信
            System.out.println(i);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class RunnableImp implements Runnable {

    @Override
    public void run() {
        System.out.println("run()");
    }
}

class CallableImp implements Callable<Integer> { // 通过泛型指定返回值

    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        TimeUnit.SECONDS.sleep(3);
        return 1024; // 有返回值
    }
}